home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1994 February: Tool Chest / Dev.CD Feb 94.toast / New System Software Extensions / QuickDraw™ GX v1.0ß2 / Sample Code / Printing Samples / Printer Drivers… / ImageWriterLQ / DialogRoutines.c < prev    next >
Encoding:
Text File  |  1993-09-13  |  22.4 KB  |  824 lines  |  [TEXT/MPS ]
  1. /*---------------------------------------------------------------------------
  2. FILENAME
  3.     DialogRoutines.c
  4.  
  5. DESCRIPTION
  6.     This file contains the routines which are used to process the LQ driver's
  7.     sheetfeeder dialog.
  8.         
  9.     9/13/93 - dmh - Modified for the b2 seed.
  10.     
  11. COPYRIGHT
  12.     Copyright Apple Computer, Inc. 1992
  13.     All rights reserved. 
  14.     
  15. INTERFACE ROUTINES:
  16.     DoSheetfeederDialog
  17.  
  18. -------------------------------------------------------------------------------- */
  19.  
  20. // Include the standard Mac header files 
  21. #include "MacIncludes.h"
  22.  
  23. // Include the new QuickDraw GX graphics header files 
  24. #include <graphics routines.h>
  25. #include <graphics libraries.h>
  26. #include <math routines.h>
  27. #include <qd library.h>
  28.  
  29. // Include the required Printing Manager header files 
  30. #include <PrintingManager.h>
  31. #include <PrintingMessages.h>
  32. #include <PrintingDrivers.h>
  33. #include <Collections.h>
  34. #include <Messages.h>
  35. #include <PrintingResTypes.h>
  36. #include <PrintingErrors.h>
  37.  
  38. #include <Exceptions.h>
  39.  
  40. // Include the internal driver constants and types used by this module 
  41. #include "Resources.h"
  42. #include "UniversalMessageIntf.h"
  43. #include "DialogRoutines.h"
  44.  
  45.  
  46. /***************************************************************************************
  47. *                                                 CONSTANTS                                                         *
  48. ***************************************************************************************/                        
  49.  
  50. // Constants for accessing items in the Sheetfeeder dialog
  51.  
  52. #define    kTray1Item                4            //    Tray #1 pop-up menu
  53. #define    kTray2Item                5            //    Tray #2 pop-up menu
  54. #define    kTray3Item                6            //    Tray #3 pop-up menu
  55. #define    kPrinterPICTItem        7            //    Picture of the printer with a sheetfeeder
  56.  
  57. // Constants useful for filtering events
  58.  
  59. #define    kENTER                    0x03        // ENTER character
  60. #define    kCR                        0x0D        // Carriage return character
  61.  
  62. // Constants defining the maximum paper size supported by the LQ printer
  63.  
  64. #define    kMaxPaperWidth            ff(15)    // 15 inches is maximum width
  65. #define    kMaxPaperHeight            ff(69)    // 69 inches is maximum height
  66.  
  67.  
  68. /*********************************************************************************
  69.  *                                             TYPES                                                     *
  70.  *********************************************************************************/
  71.  
  72. // PopupMenuInfo - Structure used to initialize the tray pop-up menus 
  73.  
  74. typedef struct
  75. {
  76.     short            numTrays;        // Number of trays configured on the printer 
  77.     MenuHandle        tray1Menu;        //    handle to the tray #1 pop-up menu
  78.     MenuHandle        tray2Menu;        //    handle to the tray #2 pop-up menu
  79.     MenuHandle        tray3Menu;        //    handle to the tray #3 pop-up menu
  80. }    PopupMenuInfo,
  81.     *PopupMenuInfoPtr;
  82.     
  83.     
  84. // PaperSearchRec - Structure used to search for a paper type chosen from a pop-up menu
  85.  
  86. typedef struct
  87. {
  88.     gxPaperType            paper;            // temp. paper type reference in which to return found paper type 
  89.     Str31                paperName;        //    name of the paper to locate
  90. }    PaperSearchRec,
  91.     *PaperSearchRecPtr;
  92.     
  93.     
  94. // PopupPrivateData - Structure defining a pop-up control's private data
  95.  
  96. typedef struct
  97. {
  98.     MenuHandle        mHandle;            // handle to the menu 
  99.     short                mID;                //    menu ID
  100.     char                mPrivate[0];    //    reserved
  101. }    PopupPrivateData,
  102.     *PopupPrivateDataPtr,
  103.     **PopupPrivateDataHdl;
  104.         
  105.  
  106. /***************************************************************************************
  107. *                                         INLINE ROUTINES                                                         *
  108. ***************************************************************************************/                        
  109.  
  110. pascal void QDDrawPicture(PicHandle myPicture,const Rect *dstRect) = 0xA8F6;
  111.  
  112.  
  113. /***************************************************************************************
  114. *                                         INTERNAL ROUTINES                                                     *
  115. ***************************************************************************************/                        
  116.  
  117.  
  118. /****************************************************************************************
  119.  
  120.                             FindChosenPaperType
  121.                             
  122.     function:
  123.                 This routine is called by GXForEachPaperTypeDo, and it searches for a specific
  124.                 paper type (by name).  It terminates searching when the paper type is 
  125.                 found.  Only the names of paper that will fit into the printer will be considered.
  126.  
  127.                 
  128.     parameters:                
  129.                 paper                target paper type
  130.                 paperToFind        structure that identifies the paper type to find
  131.                 
  132.     returns:
  133.                 gxLoopStatus        gxKeepLooping => keep examining paper types
  134.                                     gxStopLooping    => no longer loop - we found the one we wanted
  135.     
  136. ****************************************************************************************/
  137. pascal gxLoopStatus FindChosenPaperType(gxPaperType paper, PaperSearchRecPtr paperToFind)
  138. {
  139.     Str31            paperName;
  140.     gxLoopStatus    status = gxKeepLooping;
  141.     gxRectangle        paperSize;
  142.     
  143.     // Get the dimensions of the paper
  144.     GXGetPaperTypeDimensions(paper, nil, &paperSize);
  145.     
  146.     // Will the paper fit into the printer?
  147.     if (    ( (paperSize.right - paperSize.left) <= FixMul(ff(72), kMaxPaperWidth) )    &&
  148.             ( (paperSize.bottom - paperSize.top) <= FixMul(ff(72), kMaxPaperHeight) )
  149.         )
  150.     {
  151.         // Retrieve the name of the paper type
  152.         GXGetPaperTypeName(paper, paperName);
  153.     
  154.         if ( IUCompString(paperName, paperToFind->paperName) == 0 )    //    T => Found the paper type
  155.         {
  156.             // Make a copy of this paper type and quit searching
  157.             GXCopyPaperType (paper, paperToFind->paper);
  158.             status = gxStopLooping;
  159.         }
  160.     }
  161.         
  162.     return(status);
  163. } 
  164. /* FindChosenPaperType */
  165.  
  166.  
  167. /****************************************************************************************
  168.  
  169.                             SaveSheetfeederSettings
  170.                             
  171.     function:
  172.                 This routine is called if the user confirms the changes in the dialog.  It
  173.                 stores updates the tray information configuration file with the user's latest
  174.                 settings.
  175.                 
  176.     parameters:                
  177.                 theDlog        pointer to the target dialog
  178.                 menuStuff    info. about the pop-up menus
  179.                 
  180.     returns:
  181.                 OSErr            error code
  182.     
  183. ****************************************************************************************/
  184. OSErr SaveSheetfeederSettings(DialogPtr theDlog, PopupMenuInfoPtr menuStuff)
  185. {
  186.     OSErr            anErr;
  187.     gxPaperType        paper;
  188.     gxJob            theJob = GXGetJob();
  189.     MenuHandle        *nextMenu;
  190.     short            i;
  191.     
  192.     // Create a temporary paper type
  193.     
  194.     paper = GXNewPaperType(theJob, NULL, NULL, NULL);
  195.     anErr = GXGetJobError(theJob);
  196.     require(anErr == noErr, GXNewPaperType);
  197.     
  198.     // For each visible pop-up menu, update its associated tray information
  199.     
  200.     for (i = kTray1Item, nextMenu = &(menuStuff->tray1Menu); i <= kTray3Item; ++i, ++nextMenu )
  201.     {
  202.         short        whichTray = i - kTray1Item + 1;
  203.         
  204.         if ( whichTray <= menuStuff->numTrays )    //    T => This menu is visible
  205.         {
  206.             Str31                    paperName;
  207.             short                    itemType;
  208.             ControlHandle        item;
  209.             Rect                    itemRect;
  210.             PaperSearchRec        paperToFind;
  211.             
  212.             // Get the name of the chosen paper type from the menu
  213.             
  214.             GetDItem(theDlog, i, &itemType, (Handle *) &item, &itemRect);
  215.             GetItem(*nextMenu, GetCtlValue(item), paperName);
  216.  
  217.             // Get the tray information for this tray
  218.             
  219.             anErr = GXGetTrayPaperType(whichTray, paper);
  220.             if (anErr == resNotFound)
  221.                 anErr = noErr;
  222.             else {
  223.                 require(anErr == noErr, GXGetTrayPaperType);
  224.             
  225.                 //    Get the referenced paper type
  226.     
  227.                 paperToFind.paper = paper;
  228.                 BlockMove((Ptr) paperName, (Ptr) paperToFind.paperName, sizeof(Str31));
  229.                 
  230.                 GXForEachJobPaperTypeDo(theJob, FindChosenPaperType, &paperToFind, false);        // Don't consider the format device in this search    
  231.                 anErr = GXGetJobError(theJob);
  232.                 require(anErr == noErr, GXForEachPaperTypeDo);
  233.                 
  234.                 // Update the paper type for this tray
  235.                 
  236.                 anErr = GXSetTrayPaperType(whichTray, paper);
  237.                 require(anErr == noErr, GXSetTrayPaperType);
  238.             }
  239.         }
  240.         else    //     T => No more visible pop-up menus
  241.             break;
  242.     }
  243.  
  244.  
  245. /******* Clean-up *******/
  246.  
  247. GXSetTrayPaperType:
  248. GXGetTrayPaperType:
  249. GXForEachPaperTypeDo:
  250.     GXDisposePaperType(paper);
  251.  
  252. GXNewPaperType:
  253.     return(anErr);
  254. }
  255. /* SaveSheetfeederSettings */
  256.  
  257.  
  258. /****************************************************************************************
  259.  
  260.                             SheetfeederDialogFilter
  261.                             
  262.     function:
  263.                 This routine is the filter proc. that is passed to ModalDialog when the 
  264.                 sheetfeeder dialog is displayed.  It filters for the <cr> and <enter> keys
  265.                 and for command-".".
  266.                 
  267.     parameters:                
  268.                 theDlog        pointer to the target dialog
  269.                 theEvent        the event to be filtered
  270.                 itemHit        the item which was selected; may be mapped to ok or cancel
  271.                 
  272.     returns:
  273.                 Boolean        true if we've filtered the event; false if ModalDialog should process it
  274.     
  275. ****************************************************************************************/
  276. pascal Boolean SheetfeederDialogFilter(DialogPtr theDlog, EventRecord *theEvent, short *itemHit)
  277. {
  278.     Boolean        eventFiltered = false;
  279.     short        itemType;
  280.     Rect        itemRect;
  281.     Handle        item;
  282.     
  283.     if ( (theEvent->what == keyDown) || (theEvent->what == autoKey) ) 
  284.     {
  285.         char        c;
  286.         
  287.         c = (char) (theEvent->message & charCodeMask);
  288.         
  289.         if ( (c == kCR) || (c == kENTER) )     //    T => User typed carriage return or enter key; filter event
  290.         {
  291.             *itemHit = ok;
  292.             eventFiltered = true;
  293.         }
  294.         else
  295.         if ( (c == '.') && ((theEvent->modifiers & cmdKey) != 0) )    //    T => User typed <cmnd>-"."
  296.         {
  297.             *itemHit = cancel;
  298.             eventFiltered = true;
  299.         }
  300.         
  301.         if (eventFiltered)    //    T => Highlight the buttons appropriately
  302.         {
  303.             ControlHandle    theCtrl;
  304.             long                ignore;
  305.             
  306.             // Highlight the OK button momentarily
  307.             
  308.             GetDItem(theDlog, *itemHit, &itemType, (Handle *) &theCtrl, &itemRect);
  309.             HiliteControl(theCtrl, inButton);
  310.             Delay(10, &ignore);
  311.             HiliteControl(theCtrl, 0);
  312.         }
  313.     }
  314.     else
  315.     if (theEvent->what == updateEvt)    //    T => Outline the OK button
  316.     {
  317.         GrafPtr    oldPort;
  318.         
  319.         GetPort(&oldPort);
  320.         SetPort(theDlog);
  321.         
  322.         GetDItem(theDlog, ok, &itemType, &item, &itemRect);
  323.         PenSize(3, 3);
  324.         InsetRect(&itemRect, -4, -4);
  325.         FrameRoundRect(&itemRect, 16, 16);
  326.         PenNormal();
  327.  
  328.         SetPort(oldPort);
  329.     }
  330.  
  331.     return(eventFiltered);
  332. }
  333. /* SheetfeederDialogFilter */
  334.  
  335.  
  336. /****************************************************************************************
  337.  
  338.                             UniquePaperName
  339.                             
  340.     function:
  341.                 This routine searches for a specified paper type name in a specific pop-up
  342.                 menu.  If it finds the name, the routine returns false; otherwise it
  343.                 returns true.
  344.                 
  345.     parameters:                
  346.                 hMenu            handle to the menu to examine
  347.                 paperName    name of the paper type to insert to check for
  348.                 
  349.     returns:
  350.                 Boolean        true if paper type name is unique; false otherwise
  351.     
  352. ****************************************************************************************/
  353. Boolean UniquePaperName(MenuHandle hMenu, Str31 paperName)
  354. {
  355.     Boolean        isUnique = true;
  356.     short        i;
  357.     Str255        menuString;
  358.     
  359.     for (i = CountMItems(hMenu); i > 0; --i) 
  360.     {
  361.         GetItem(hMenu, i, menuString);
  362.         
  363.         if ( IUCompString(paperName, menuString) == 0 )     //    T => Found the string
  364.         {
  365.             isUnique = false;
  366.             break;
  367.         }
  368.     }
  369.     
  370.     return(isUnique);
  371. }  
  372. /* UniquePaperName */
  373.  
  374.  
  375. /****************************************************************************************
  376.  
  377.                             AddPaperName
  378.                             
  379.     function:
  380.                 This routine is called by GXForEachPaperTypeDo, and it adds a paper name to 
  381.                 each visible pop-up menu if the name does not already appear in the menu.
  382.                 Only the names of paper that will fit into the printer will be listed
  383.                 in the pop-up menu.
  384.                 
  385.     parameters:                
  386.                 paper                target paper type
  387.                 menuStuff        pointer to info about the dialog's pop-up menus
  388.                 
  389.     returns:
  390.                 gxLoopStatus        gxKeepLooping => examine all target paper types
  391.     
  392. ****************************************************************************************/
  393. pascal gxLoopStatus AddPaperName(gxPaperType paper, PopupMenuInfoPtr menuStuff)
  394. {
  395.     Str31            paperName;
  396.     gxRectangle        paperSize;
  397.     
  398.     // Get the dimensions of the paper
  399.     GXGetPaperTypeDimensions(paper, nil, &paperSize);
  400.     
  401.     // Will the paper fit into the printer?
  402.     if (    ( (paperSize.right - paperSize.left) <= FixMul(ff(72), kMaxPaperWidth) )    &&
  403.             ( (paperSize.bottom - paperSize.top) <= FixMul(ff(72), kMaxPaperHeight) )
  404.         )
  405.     {
  406.         // Retrieve the name of the paper type
  407.         GXGetPaperTypeName(paper, paperName);
  408.     
  409.         if ( UniquePaperName(menuStuff->tray1Menu, paperName) )    //    T => If the paper name is unique, add it
  410.         {
  411.             MenuHandle        *nextMenu;
  412.             Str255            theName;
  413.             short                i;
  414.             
  415.             // For each visible menu, add the name to the pop-up
  416.             
  417.             for (i = kTray1Item, nextMenu = &(menuStuff->tray1Menu); i <= kTray3Item; ++i, ++nextMenu )
  418.             {
  419.                 if ( (i - kTray1Item + 1) <= menuStuff->numTrays )    //    T => This menu is visible
  420.                 {
  421.                     AppendMenu(*nextMenu, "\p ");
  422.                     BlockMove(paperName, theName, sizeof(Str31));
  423.                     SetItem(*nextMenu, CountMItems(*nextMenu), theName);
  424.                 }
  425.                 else    //     T => No more visible pop-up menus
  426.                     break;
  427.             }
  428.         }
  429.     }
  430.         
  431.     return (gxKeepLooping);
  432. } 
  433. /* AddPaperName */
  434.  
  435.  
  436. /****************************************************************************************
  437.  
  438.                             LoadPaperNames
  439.                             
  440.     function:
  441.                 This routine loads the names of each uniquely named paper type into each of the
  442.                 tray pop-up menus that are still visible.
  443.                 
  444.     parameters:                
  445.                 pDlg            Pointer to the target dialog
  446.                 whichItem    Index in the DITL of the item to draw
  447.                 
  448.     returns:
  449.                 OSErr            error code
  450.     
  451. ****************************************************************************************/
  452. OSErr LoadPaperNames(DialogPtr theDlog, PopupMenuInfoPtr menuStuff)
  453. {
  454.     short                itemType;
  455.     Rect                itemRect;
  456.     ControlHandle        item;
  457.     short                i;
  458.     gxJob                theJob = GXGetJob();
  459.     OSErr                anErr;
  460.  
  461.     GXForEachJobPaperTypeDo(theJob,  AddPaperName,  menuStuff, false);        // Don't consider the format device in this search    
  462.     anErr = GXGetJobError(theJob);
  463.  
  464.     if (anErr == noErr)
  465.     {
  466.         MenuHandle        *nextMenu;
  467.         
  468.         // For each visible menu, initialize the pop-up control
  469.         
  470.         for (i = kTray1Item, nextMenu = &(menuStuff->tray1Menu); i <= kTray3Item; ++i, ++nextMenu )
  471.         {
  472.             if ( (i - kTray1Item + 1) <= menuStuff->numTrays )    //    T => This menu is visible
  473.             {
  474.                 GetDItem(theDlog, i, &itemType, (Handle *) &item, &itemRect);
  475.                 
  476.                 SetCtlMin(item, 1);
  477.                 SetCtlMax(item, CountMItems(*nextMenu));
  478.                 SetCtlValue(item, 1);
  479.             }
  480.             else    //     T => No more visible pop-up menus
  481.                 break;
  482.         }
  483.     }
  484.  
  485.     return(anErr);
  486. }
  487. /* LoadPaperNames */
  488.  
  489.  
  490. /****************************************************************************************
  491.  
  492.                             SheetfeederDrawProc
  493.                             
  494.     function:
  495.                 This routine is used to draw the picture of the sheetfeeder in the configuration
  496.                 dialog.
  497.                 
  498.     parameters:                
  499.                 pDlg            Pointer to the target dialog
  500.                 whichItem    Index in the DITL of the item to draw
  501.                 
  502.     returns:
  503.                 OSErr            error code
  504.     
  505. ****************************************************************************************/
  506. pascal void SheetfeederDrawProc(WindowPtr    pDlg, short whichItem)
  507. {
  508.     SpecGlobalsHdl     hGlobals = GetMessageHandlerInstanceContext();
  509.     Handle                hItem;
  510.     Rect                    itemRect;
  511.     short                    itemType;
  512.     
  513.     GetDItem(pDlg, whichItem, &itemType, &hItem, &itemRect);
  514.  
  515.     QDDrawPicture((*hGlobals)->sheetFeederPICT, &itemRect);
  516. }
  517. /* SheetfeederDrawProc */
  518.  
  519.  
  520. /****************************************************************************************
  521.  
  522.                             GetConfigInfo
  523.                             
  524.     function:
  525.                 This routine is a utility function that returns the LQ driver's configuration
  526.                 info. from the desktop printer file.
  527.                 
  528.     parameters:                
  529.                 configInfo    Latest info fetched from the DTP file
  530.                 
  531.     returns:
  532.                 OSErr            error code
  533.     
  534. ****************************************************************************************/
  535. OSErr GetConfigInfo(IWLQConfigInfoPtr configInfo)
  536. {
  537.     OSErr                        anErr;
  538.     Str32                        deviceName;
  539.     IWLQConfigInfoHdl            hConfigData;
  540.     
  541.     // Get the name of the desktop printer file
  542.     GXGetPrinterName(GXGetJobOutputPrinter(GXGetJob()), deviceName);
  543.  
  544.     // Get the config info
  545.     anErr = GXFetchDTPData(deviceName, kIWLQConfigType, kIWLQConfigID, (Handle *) &hConfigData);
  546.     require(anErr == noErr, GXFetchDTPData);
  547.     
  548.     // Return the config. info
  549.     *configInfo = **hConfigData;
  550.     
  551.     // Kill the temporary handle
  552.     DisposHandle((Handle) hConfigData);
  553.     
  554.  
  555. /******* Clean-up *******/
  556.  
  557. GXFetchDTPData:
  558.     return(anErr);
  559. }
  560. /* GetConfigInfo */
  561.  
  562.  
  563. /****************************************************************************************
  564.  
  565.                             InitSheetfeederDialog
  566.                             
  567.     function:
  568.                 This routine is called to initialize the sheet feeder dialog and to set the
  569.                 state of the pop-up menus based upon the latest configuration information.
  570.                 
  571.     parameters:                
  572.                 theDlog        returns the pointer to the dialog window if init. was succesful; otherwise nil
  573.                 menuStuff    info about the dialog's pop-up menus
  574.                 
  575.     returns:
  576.                 OSErr        error code
  577.     
  578. ****************************************************************************************/
  579. OSErr InitSheetfeederDialog(DialogPtr *theDlog, PopupMenuInfoPtr menuStuff)
  580. {
  581.     OSErr                anErr = noErr;
  582.     DialogPtr            dLog;
  583.     IWLQConfigInfo        configInfo;
  584.     SpecGlobalsHdl         hGlobals = GetMessageHandlerInstanceContext();
  585.     short                itemType;
  586.     Rect                itemRect;
  587.     Handle                hItem;
  588.     gxPaperType            paper;
  589.     
  590.     // Initialize variables
  591.     *theDlog = nil;
  592.     (*hGlobals)->sheetFeederPICT = nil;
  593.     
  594.     dLog = GetNewDialog(kSheetFeederDLOG, nil, (WindowPtr) (-1));
  595.     if (dLog == nil)
  596.     {
  597.         anErr = MemError();
  598.         if (anErr == noErr)
  599.             anErr = resNotFound;
  600.         
  601.         require(anErr == noErr, GetNewDialog);
  602.     }
  603.  
  604.     // Fetch the latest configuration info. from the DTP file
  605.     anErr = GetConfigInfo(&configInfo);
  606.     require(anErr == noErr, GetConfigInfo);
  607.     
  608.     // Determine which sheetfeeder picture to display in the dialog
  609.     {
  610.         short            whichPICT;
  611.         Handle            thePICT;
  612.         
  613.         switch (configInfo.numTrays)
  614.         {
  615.             case 1:    whichPICT = kOneTrayPICT;         break;
  616.             case 2:    whichPICT = kTwoTrayPICT;         break;
  617.             case 3:    whichPICT = kThreeTrayPICT;     break;
  618.         }
  619.         
  620.         anErr = Send_GXFetchTaggedDriverData('PICT', whichPICT, (Handle *) &thePICT);
  621.         require(anErr == noErr, GXFetchTaggedDriverData);
  622.         
  623.         // Save this handle in our globals
  624.  
  625.         HNoPurge(thePICT);
  626.         (*hGlobals)->sheetFeederPICT = (PicHandle) thePICT;
  627.         
  628.         // Setup the DrawProc for this picture item
  629.         
  630.         GetDItem(dLog, kPrinterPICTItem, &itemType, &hItem, &itemRect);
  631.         SetDItem(dLog, kPrinterPICTItem, itemType, (Handle) SheetfeederDrawProc, &itemRect);
  632.     }
  633.     
  634.     // Now fill in the pop-up menu paper type names and hide any pop-ups that don't apply
  635.     // to the current configuration
  636.     {
  637.         PopupPrivateDataHdl            privData;
  638.         short                        i;
  639.         MenuHandle                    *nextMenu;
  640.         
  641.         // Hide those pop-ups which don't apply to the current configuration
  642.         if (configInfo.numTrays < 3)
  643.         {
  644.             HideDItem(dLog, kTray3Item);
  645.         }
  646.  
  647.         if (configInfo.numTrays < 2)
  648.         {
  649.             HideDItem(dLog, kTray2Item);
  650.         }
  651.         
  652.         // Init. the menuStuff structure in order to load the paper names into the pop-ups
  653.         
  654.         menuStuff->numTrays = configInfo.numTrays;
  655.  
  656.         for (i = kTray1Item, nextMenu = &(menuStuff->tray1Menu); i <= kTray3Item; ++i, ++nextMenu)
  657.         {
  658.             GetDItem(dLog, i, &itemType, &hItem, &itemRect);
  659.             privData = (PopupPrivateDataHdl) (* (ControlHandle) hItem)->contrlData;
  660.             *nextMenu = (*privData)->mHandle;
  661.         }
  662.         
  663.         // Now load the paper type names into the remaining pop-up menus
  664.         anErr = LoadPaperNames(dLog, menuStuff);
  665.         require(anErr == noErr, LoadPaperNames);
  666.     }
  667.     
  668.     // Retrieve the latest paper<->tray configuration and force the pop-up(s) to display the
  669.     // correct paper name (i.e. the last selected paper name).
  670.     {
  671.         gxJob            theJob = GXGetJob();
  672.         MenuHandle    *nextMenu;
  673.         short            i;
  674.         
  675.         // Create a temporary paper type
  676.         
  677.         paper = GXNewPaperType(theJob, NULL, NULL, NULL);
  678.         anErr = GXGetJobError(theJob);
  679.         require(anErr == noErr, GXNewPaperType);
  680.         
  681.         // For each visible pop-up menu, try to display the last choosen paper type
  682.         
  683.         for (i = kTray1Item, nextMenu = &(menuStuff->tray1Menu); i <= kTray3Item; ++i, ++nextMenu )
  684.         {
  685.             short        whichTray = i - kTray1Item + 1;
  686.             
  687.             if ( whichTray <= menuStuff->numTrays )    //    T => This menu is visible
  688.             {
  689.                 Str255    menuString;
  690.                 short        j;
  691.                 Str31        paperName;
  692.                 
  693.                 // Get the tray information for this tray
  694.                 
  695.                 anErr = GXGetTrayPaperType(whichTray, paper);
  696.                 if (anErr == resNotFound)
  697.                     anErr = noErr;
  698.                 else {
  699.                     require(anErr == noErr, GXGetTrayPaperType);
  700.                 
  701.                     // Fetch the name of the paper type
  702.                     GXGetPaperTypeName(paper, paperName);
  703.                     
  704.                     // For each paper name in the menu, try to find a match
  705.                     
  706.                     for (j = CountMItems(*nextMenu); j > 0; --j) 
  707.                     {
  708.                         GetItem(*nextMenu, j, menuString);
  709.                         
  710.                         if ( IUCompString(paperName, menuString) == 0 )     //    T => Found the string
  711.                         {
  712.                             //    Make this paper name the current pop-up menu selection
  713.                             
  714.                             GetDItem(dLog, i, &itemType, &hItem, &itemRect);
  715.                             SetCtlValue((ControlHandle) hItem, j);
  716.                             break;
  717.                         }
  718.                     }
  719.                 }
  720.             }
  721.             else    //     T => No more visible pop-up menus
  722.                 break;
  723.         }
  724.  
  725.         // Dump the temporary paper type
  726.         GXDisposePaperType(paper);
  727.     }
  728.     
  729.     *theDlog = dLog;
  730.     
  731.     return(anErr);
  732.     
  733.     
  734. /******* Clean-up *******/
  735.  
  736. GXGetTrayPaperType:
  737.     GXDisposePaperType(paper);
  738.  
  739. GXNewPaperType:
  740. LoadPaperNames:
  741.     DisposHandle((Handle) (*hGlobals)->sheetFeederPICT);
  742.     
  743. GXFetchTaggedDriverData:
  744. GetConfigInfo:
  745.     DisposDialog(dLog);
  746.     
  747. GetNewDialog:
  748.     return(anErr);
  749. }
  750. /* InitSheetfeederDialog */
  751.  
  752.  
  753. /***************************************************************************************
  754. *                                         INTERFACE ROUTINES                                                     *
  755. ***************************************************************************************/                        
  756.  
  757. /****************************************************************************************
  758.  
  759.                             DoSheetfeederDialog
  760.                             
  761.     function:
  762.                 This routine is called to display and process the LQ driver's sheetfeeder
  763.                 dialog.  This dialog is displayed when the user selects the "Input Trays…" menu
  764.                 item from the Finder menu.  This dialog allows the user to specify the type
  765.                 of paper that's contained within the printer's sheet feeder.
  766.                 
  767.     parameters:                
  768.                 None
  769.                 
  770.     returns:
  771.                 OSErr        error code
  772.     
  773. ****************************************************************************************/
  774. OSErr DoSheetfeederDialog(void)
  775. {
  776.     OSErr                    anErr = noErr;
  777.     GrafPtr                    oldPort;
  778.     DialogPtr                theDlog;
  779.     short                    itemHit = 0;
  780.     PopupMenuInfo            menuStuff;
  781.     SpecGlobalsHdl             hGlobals = GetMessageHandlerInstanceContext();
  782.     
  783.     GetPort(&oldPort);
  784.     
  785.     // Initialize the dialog before displaying it
  786.     anErr = InitSheetfeederDialog(&theDlog, &menuStuff);
  787.     require(anErr == noErr, InitSheetfeederDialog);
  788.     
  789.     // Make sure the dialog is now visible
  790.     ShowWindow(theDlog);
  791.     SelectWindow(theDlog);
  792.     
  793.     // Process events in the window
  794.     while ( (itemHit != ok) && (itemHit != cancel) )
  795.     {
  796.        ModalDialog((ModalFilterProcPtr) SheetfeederDialogFilter, &itemHit);
  797.     }
  798.  
  799.     //    Do we need to save the new settings?
  800.     if (itemHit == ok)
  801.         anErr = SaveSheetfeederSettings(theDlog, &menuStuff);
  802.         
  803.     // Dump the dialog and picture handle
  804.     
  805.     if ( (*hGlobals)->sheetFeederPICT != nil )
  806.         DisposHandle((Handle) (*hGlobals)->sheetFeederPICT);
  807.         
  808.     DisposDialog(theDlog);
  809.     
  810.     SetPort(oldPort);
  811.  
  812.     return(anErr);
  813.     
  814.     
  815. /******* Clean-up *******/
  816.  
  817. InitSheetfeederDialog:
  818.     SetPort(oldPort);
  819.     
  820.     return(anErr);
  821. }
  822. /* DoSheetfeederDialog */
  823.  
  824.